package top.i89ck.modules.admin;

import java.util.List;
import java.util.Map;

import com.jfinal.aop.Inject;
import com.jfinal.core.Controller;
import com.jfinal.core.Path;
import com.jfinal.core.paragetter.Para;
import com.jfinal.kit.JsonKit;
import org.opensource.jfhelper.utils.Ret;
import com.jfinal.plugin.activerecord.Page;
import top.i89ck.common.jqgrid.JqPager;
import top.i89ck.common.jqgrid.View;
import top.i89ck.modules.model.Dict;
import top.i89ck.modules.model.Option;
import top.i89ck.modules.service.DictService;
import top.i89ck.modules.service.OptionService;
import top.i89ck.modules.utils.Const;
import top.i89ck.modules.utils.Pager;

import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.io.file.FileReader;
import cn.hutool.core.io.resource.ClassPathResource;
import cn.hutool.core.util.StrUtil;

/**
 * 权限管理操作类， 提供权限的相关管理工作。
 *
 * @author Seiya
 */
@Path(value = "admin/option", viewPath = top.i89ck.common.utils.Const.BASE_PATH + "/option")
public class OptionController extends Controller {


    @Inject
    private OptionService optService;
    @Inject
    private DictService dictService;

    /**
     * 打开系统中的权限管理列表页
     */
    public void index() {
        Map<String, String> types = dictService.getSubMap(Const.DICT_OPTION_TYPE_MENU);
        set("types", JsonKit.toJson(types));
        set("option", getAttr(Const.CFG_OPTION));
        render("option.html");
    }

    /**
     * 查询系统中的菜单权限树
     */
    public List<Option> query() {
        return optService.getTreeList();
    }

    /**
     * 新增权限， 加载系统中所有的一级权限信息
     */
    public void addMenu() {
        initOptionMenu();
        set("option", new Option());
        render("option_menu.html");
    }

    /**
     * 修改菜单权限数据
     *
     * @param optionId
     */
    public void updateMenu(Long optionId) {
        initOptionMenu();
        Option option = optService.findById(optionId);
        set("option", option);
        render("option_menu.html");
    }

    /**
     * 初始化菜单权限。 加载菜单数据的必须要初始化的数据
     */
    private void initOptionMenu() {
        List<Dict> types = dictService.getSubList(Const.DICT_OPTION_TYPE_MENU);
        set("types", types);
        List<Option> roots = optService.getRoots();
        set("roots", roots);
    }

    /**
     * 新增或修改系统中的权限数据
     *
     * @param option
     */
    public Ret save(@Para("") Option option) {
        boolean succeed = optService.save(option);
        return succeed ? Ret.ok() : Ret.fail("保存失败，请重新操作");
    }

    /**
     * 删除系统中的某个菜单权限， 如果有下级菜单， 不可删除， 需要先删除所有的下级菜单才能删除本菜单
     */
    public Ret delMenu(String optionId) {
        boolean succeed = optService.delAll(CollUtil.newArrayList(optionId));
        return succeed ? Ret.ok() : Ret.fail("删除失败，请重新操作");
    }

    /**
     * 系统权限设置， 提供权限的功能分类设置， 比如：设置表格列、搜索条件、功能按钮等
     *
     * @param optionId
     */
    public void setting(Long optionId) {
        Option option = optService.getOptionByDictType(Const.DICT_OPTION_TYPE_MENU_TOPS, optionId);
        set("optionId", optionId);
        if (null == option) {
            List<Dict> funcs = dictService.getSubList(Const.DICT_OPTION_TYPE_FUNC);
            set("funcs", funcs);
            set("defType", CollUtil.isNotEmpty(funcs) ? funcs.get(0).getData() : "");
            render("option_setting.html");
        } else {
            set("option", option);
            set("func", getTemplateFile("tops_msg.func"));
            render("option_topmsg.html");
        }

    }

    /**
     * 打开功能权限的展示页面。
     *
     * @param optionId
     * @param type
     */
    public void func(Long optionId, Integer type) {
        Dict func = dictService.getOne(type + "", Const.DICT_OPTION_TYPE_FUNC);
        set("func", func);
        Option funcGroup = optService.getFirstSubOption(optionId, type);
        set("funcGroup", funcGroup);
        set("optionIdx", optionId);
        if (Const.OPTION_TYPE_BTNS == type) {
            render("option_func_btns.html");
        }
        if (Const.OPTION_TYPE_COLS == type) {
            render("option_func_cols.html");
        }
        if (Const.OPTION_TYPE_PARA == type) {
            render("option_func_para.html");
        }
    }

    /**
     * 功能列表查询， 用于实现查询某个功能分组下的功能列表
     *
     * @param pager
     * @param optionId
     */
    public JqPager queryFunc(@Para("") Pager pager, Long optionId) {
        Page<Option> page = optService.getSubOptionPage(pager, optionId);
        return new JqPager(page);
    }

    /**
     * 打开新增权限中的功能数据
     */
    public void addFunc(Long optionId) {
        set("parentId", optionId);
        Option parent = optService.findById(optionId);
        int type = parent.getType();
        Option option = new Option();
        option.setType(type);
        set("option", option);

        // 当类型是按钮的时候，打开的页面
        if (Const.OPTION_TYPE_BTNS == type) {
            set("btnFunc", getTemplateFile("grid_btn.func"));
            render("option_func_btns_edit.html");
        }
        // 当类型是表格的时候，打开的页面
        if (Const.OPTION_TYPE_COLS == type) {
            set("colFunc", getTemplateFile("grid_col.func"));
            render("option_func_cols_edit.html");
        }
        // 当类型是查询的时候，打开的页面
        if (Const.OPTION_TYPE_PARA == type) {
            render("option_func_para_edit.html");
        }
    }

    /**
     * 获取模板中的默认数据。 直接读取文件数据
     *
     * @param fileName
     * @return
     */
    private String getTemplateFile(String fileName) {
        ClassPathResource resource = new ClassPathResource("template/jqgrid/func/" + fileName);
        FileReader reader = new FileReader(resource.getFile());
        return reader.readString();
    }

    /**
     * 修改某个具体的功能方法信息
     *
     * @param optionId
     */
    public void updateFunc(Long optionId) {
        Option option = optService.findById(optionId);
        set("option", option);
        // 当类型是按钮的时候，打开的页面
        if (Const.OPTION_TYPE_BTNS == option.getType()) {
            render("option_func_btns_edit.html");
        }
        // 当类型是表格的时候，打开的页面
        if (Const.OPTION_TYPE_COLS == option.getType()) {
            render("option_func_cols_edit.html");
        }
        // 当类型时条件的时候，打开的页面
        if (Const.OPTION_TYPE_PARA == option.getType()) {
            render("option_func_para_edit.html");
        }
    }

    /**
     * 权限的数据排列上移操作。 用于实现字段的上移
     *
     * @param optionId
     */
    public Ret moveUp(Long optionId) {
        Option previous = optService.getPreviousOption(optionId);
        if (null != previous) {
            boolean succeed = optService.moveUp(previous, optionId);
            return succeed ? Ret.ok() : Ret.fail("上移失败， 请重新操作");
        } else {
            return Ret.fail("当前已处在最上级");
        }
    }

    /**
     * 批量删除选中的数据。 用于实现权限数据的批量删除
     *
     * @param optionIds
     */
    public Ret delAll(String optionIds) {
        boolean succeed = optService.delAll(StrUtil.splitTrim(optionIds, ","));
        return succeed ? Ret.ok() : Ret.fail("删除失败，请重新操作");
    }

    /**
     * 显示某个功能权限的具体详情信息。
     *
     * @param optionId
     */
    public void showFunc(Long optionId) {
        Option option = optService.findById(optionId);
        set("option", option);
        render("option_func_detail.html");
    }

}
